package cn.t.repository.impl.device;

import cn.t.constants.CommonConstants;
import cn.t.constants.ParamConstants;
import cn.t.converter.device.CargowaySkuConverter;
import cn.t.core.repoistory.RepositoryImpl;
import cn.t.model.device.CargowaySkuDO;
import cn.t.model.sku.SkuDO;
import cn.t.persistence.entity.device.CargowaySkuPO;
import cn.t.persistence.mapper.device.CargowaySkuMapper;
import cn.t.repository.device.CargowaySkuRepository;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Repository;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 货道商品表(CargowaySku)数据仓库
 *
 * @author t
 * @since 2024-05-24 10:18:08
 */
@Slf4j
@Repository
@AllArgsConstructor
public class CargowaySkuRepositoryImpl extends RepositoryImpl<CargowaySkuMapper, CargowaySkuPO, CargowaySkuConverter, CargowaySkuDO> implements CargowaySkuRepository {


    @Override
    public List<CargowaySkuDO> findByModel(CargowaySkuDO cargowaySkuDO, int start, Integer pageSize, String field, String direction) {

        String lastSql = StringUtils.hasText(field) ?
                " order by " + field + " " + direction + " limit " + start + "," + pageSize : " limit " + start + "," + pageSize;

        List<CargowaySkuPO> list = getWrapper(cargowaySkuDO).last(lastSql).list();
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        }

        return list.stream().map(converter::po2Model).collect(Collectors.toList());
    }

    private LambdaQueryChainWrapper<CargowaySkuPO> getWrapper(CargowaySkuDO cargowaySkuDO) {
        LambdaQueryChainWrapper<CargowaySkuPO> wrapper = lambdaQuery();
        if (!ObjectUtils.isEmpty(cargowaySkuDO.getDeviceId())) {
            wrapper.eq(CargowaySkuPO::getDeviceId, cargowaySkuDO.getDeviceId());
        }
        if (!ObjectUtils.isEmpty(cargowaySkuDO.getCargowayId())) {
            wrapper.eq(CargowaySkuPO::getCargowayId, cargowaySkuDO.getCargowayId());
        }
        if (!ObjectUtils.isEmpty(cargowaySkuDO.getSkuCode())) {
            wrapper.eq(CargowaySkuPO::getSkuCode, cargowaySkuDO.getSkuCode());
        }
        if (!ObjectUtils.isEmpty(cargowaySkuDO.getSkuName())) {
            wrapper.eq(CargowaySkuPO::getSkuName, cargowaySkuDO.getSkuName());
        }
        if (!ObjectUtils.isEmpty(cargowaySkuDO.getAlarmLimit())) {
            wrapper.eq(CargowaySkuPO::getAlarmLimit, cargowaySkuDO.getAlarmLimit());
        }

        wrapper.in(!CollectionUtils.isEmpty(cargowaySkuDO.getDeviceIds()), CargowaySkuPO::getDeviceId, cargowaySkuDO.getDeviceIds());
        wrapper.in(!CollectionUtils.isEmpty(cargowaySkuDO.getSkuCodes()), CargowaySkuPO::getSkuCode, cargowaySkuDO.getSkuCodes());
        return wrapper;
    }

    @Override
    public long count(CargowaySkuDO cargowaySkuDO) {
        return getWrapper(cargowaySkuDO).count();
    }

    @Override
    public Boolean addOrUpdateBatch(List<CargowaySkuDO> cargowaySkuDOS) {
        if (CollectionUtils.isEmpty(cargowaySkuDOS)){
            return false;
        }
        return this.saveOrUpdateBatch(converter.do2poList(cargowaySkuDOS));
    }

    @Override
    public Boolean updateBatch(List<CargowaySkuDO> cargowaySkuDOS) {
        if (CollectionUtils.isEmpty(cargowaySkuDOS)){
            return false;
        }
        return this.updateBatchById(converter.do2poList(cargowaySkuDOS), ParamConstants.EXPORTPAGEMAXSIZE);
    }

    @Override
    public void update(String skuCode, SkuDO sku) {

        // sku禁用，自动下架
        if (CommonConstants.ZERO.equals(sku.getStatus())) {
            this.remove(new LambdaQueryWrapper<CargowaySkuPO>().eq(CargowaySkuPO::getSkuCode, skuCode));
            return;
        }

        if (sku.getId() == null) {
            return;
        }

        LambdaUpdateWrapper<CargowaySkuPO> wrapper = new LambdaUpdateWrapper<>();
        wrapper.set(sku.getWeight() != null, CargowaySkuPO::getSkuWeight, sku.getWeight())
                .set(StringUtils.hasText(sku.getSkuName()), CargowaySkuPO::getSkuName, sku.getSkuName())
                .set(StringUtils.hasText(sku.getSkuImg()), CargowaySkuPO::getSkuImg, sku.getSkuImg())
                .set(sku.getId() != null, CargowaySkuPO::getSkuId, sku.getId())
                .set(sku.getErrorRate() != null, CargowaySkuPO::getErrorRate, sku.getErrorRate())
                .eq(CargowaySkuPO::getSkuCode, skuCode);

        this.update(wrapper);
    }

    @Override
    public void removeBatch(List<CargowaySkuDO> cargowaySkuList) {
        this.removeBatchByIds(cargowaySkuList.stream().map(f -> this.converter.model2Po(f)).collect(Collectors.toList()));
    }

    @Override
    public List<CargowaySkuDO> getGroupBySku(List<Long> deviceIds) {
        return getBaseMapper().getGroupBySku(deviceIds);
    }

    @Override
    public List<CargowaySkuDO> getNoAndIntervery(Long deviceId, String skuCode) {
        return getBaseMapper().getNoAndIntervery(deviceId, skuCode);
    }


}
